﻿package com.csd.excelreader;

import java.util.*;
import java.util.regex.*;

import org.apache.poi.hssf.usermodel.HSSFRichTextString;

public class ExcelReaderDriver 
{

	/*
	 * Excel读取接口
	 */
	private ExcelReader reader = null;

	/**
	 * 获取行号
	 * @return
	 */
	public int getCurrRowNo ()
	{
		return reader.getRowNo();
	}
	
	public ExcelReaderDriver ()
	{
	}
	
	/**
	 * 构造方法 ExcelReaderDriver
	 * 含参数的构造函数，一边初始化时就载入输入文件
	 * @param inputFilePath 输入文件的路径
	 */
	public ExcelReaderDriver ( String inputFilePath ) 
	{
		this.reader = new ExcelReader ( inputFilePath );
	};
	
	/**
	 * 方法 loadInputFile
	 * 加载输入文件
	 * @param inputFilePath
	 * @return 成功与否
	 */
	public boolean loadInputFile ( String inputFilePath )
	{
		ExcelReader temp_reader = new ExcelReader ();
		if ( temp_reader.loadInputFileByPath ( inputFilePath ) )
		{
			this.reader = temp_reader;
			return true;
		}
		else
		{
			return false;
		}
	};
	
	/**
	 * 方法 chackFormatForString
	 * 检查指定位置的 Cell，检查它是否是字符串且长度是否在制定的范围内，
	 * 即使本身不是字符串也尽量将其转为字符串来检查,如果无法转换则返回假
	 * 单元格内的字符串的长度大于或等于下界，小于或等于上界为合法
	 * @param index 指定Cell的位置
	 * @param upperLimit 指定字符串的长度上限
	 * @param lowerLimit 指定字符串的长度下限
	 * @return 是否符合要求
	 */
	public boolean checkFormatForString ( int index, int upperLimit, int lowerLimit )
	{
		String temp = this.readCellAsString ( index );
		
		if ( temp == null )
		{
			return false;
		}
		
		int len = temp.length();
		
		if ( len > upperLimit || len < lowerLimit)
		{
			return false;
		}
		
		return true;
	};
	
	/**
	 * 方法 checkFormatForNumeric
	 * 检查指定位置的 Cell，检查它是否是数字，是否符合浮点要求，值是否在制定的范围内，
	 * 单元格内的值大于或等于下界，小于或等于上界为合法，若允许是浮点则整数也合法
	 * @param index 指定Cell的位置
	 * @param upperLimit 指定上限
	 * @param lowerLimit 指定下限
	 * @param floatEnable 是否允许浮点数
	 * @return 是否符合要求
	 */
	public boolean checkFormatForNumeric 
		( int index, double upperLimit, double lowerLimit, boolean floatEnable )
	{
		if ( !reader.isNumeric ( index ) )
		{
			return false;
		}
		double val = reader.getCellNumericValue ( index );
		
		if ( !floatEnable && val != (int)val )
		{
			return false;
		}
		
		if ( val > upperLimit || val < lowerLimit)
		{
			return false;
		}
		
		return true;
	};
	
	/**
	 * 方法 checkFormatForDate
	 * 检查指定的 cell 是否是日期类型，且时间是否在指定的范围内
	 * 注意：通常非负的数字都能够被认定为时间日期，所以如果不是必须的，一般不要把变量认定为时间，
	 *       以免出现误解
	 *       此外，能够识别的日期范围最早为1900年，最迟为9999年，越界的时间将无法识别
	 * @param index 指定Cell的位置
	 * @param upperLimit 指定上限
	 * @param lowerLimit 指定下限
	 * @return 是否符合要求
	 */
	public boolean checkFormatForDate ( int index, Date upperLimit, Date lowerLimit )
	{
		Date temp_date = reader.getCellDateValue(index);
		if ( temp_date == null )
		{
			return false;
		}
		if ( lowerLimit.compareTo ( temp_date ) > 0 
				|| upperLimit.compareTo ( temp_date ) < 0 )
		{
			return false;
		}
		return true;
	};
	
	/**
	 * 方法 checkFormatForBoolean
	 * 检查指定的 cell 是否是布尔类型
	 * @param index
	 * @return 是否符合要求
	 */
	public boolean checkFormatForBoolean ( int index )
	{
		return reader.isBoolean ( index );
	};
	
	/**
	 * 方法 checkFormatForEmpty
	 * 检查指定位置的Cell的值是否为空，空格、回车、换行、制表符都将认为是空的
	 * @param index 指定Cell的位置
	 * @return 全为空值返回真，否则返回假
	 */
	public boolean checkFormatForEmpty ( int index )
	{
		/*
		 * 检查是否是布尔型,能判定为布尔型则一定不为空
		 */
		if ( reader.isBoolean ( index ) )
		{
			return false;
		}
		
		/*
		 * 检查是否是数字，如果是数字则一定不为空
		 */
		if ( reader.isNumeric ( index ) )
		{
			return false;
		}
		
		/*
		 * 将其视为字符串变量
		 */
		HSSFRichTextString rs = reader.getCellRichStringValue( index );
		String temp_string = null;
		
		if(rs != null){
			temp_string = rs.getString();
		}else
		{
			return true;
		}
		
		if(temp_string == null)
		{
			return true;
		}
		
		temp_string = removeBlank ( temp_string );

		if ( temp_string.length() != 0 )
			return false;
		
		return true;
	};
	
	/*
	 * 方法 removeBlank
	 * 移除字符串中的空白字符
	 * @param target 目标字符串
	 * @return 移除空白后的结果
	 */
	private String removeBlank( String target )
	{
		if ( target == null )
		{
			return "";
		}
		
		Pattern p = Pattern.compile( "\\s*|\t|\r|\n" );
		
		Matcher m = p.matcher(target);
		
		return m.replaceAll( "" );
	}
	
	/**
	 * 方法 loadRow
	 * 加载index所指定的行，行号从最上面一行开始递增，最初的一行行号为0
	 * @param index 指定行号
	 * @return 成功与否
	 */
	public boolean loadRow ( int index )
	{
		if (reader == null){
			return false;
		}
		return reader.setRow ( index );
	}
	
	/**
	 * 方法 loadNextRow
	 * 加载下一行
	 * @return 成功与否
	 */
	public boolean loadNextRow ()
	{
		if (reader == null){
			return false;
		}
		return reader.nextRow ();
	}
	
	/**
	 * 方法 loadFirstRow
	 * 载入第一行
	 * @return 成功与否
	 */
	public boolean loadFirstRow ()
	{
		if (reader == null){
			return false;
		}
		return reader.setRow ( 0 );
	}
	
	/**
	 * 方法 readCellAsBoolean
	 * 将 index 所指定的单元格视为 布尔 型的值来读取；
	 * 如果它本身就是布尔型，直接返回其值；
	 * 如果它本身是数字，只有0才代表false；
	 * 如果他是字符串，则只有为“true”时才为真
	 * 如果匹配失败返回 null
	 * @param index 指定cell的位置
	 * @return 匹配后读得的结果，如果匹配失败返回 null
	 */
	public Boolean readCellAsBoolean ( int index )
	{
		Boolean temp_bool = null;
		/*
		 * 如果它本身就是布尔型
		 */
		if ( reader.isBoolean ( index ) )
		{
			temp_bool = new Boolean( reader.getCellBooleanValue(index) );
			return temp_bool;
		}
		
		/*
		 * 如果它本身是数字，只有0才代表false
		 */
		if ( reader.isNumeric ( index ) )
		{
			if ( reader.getCellNumericValue(index) == 0 )
			{
				temp_bool = Boolean.FALSE;
			}
			else
			{
				temp_bool = Boolean.TRUE;
			}
			return temp_bool;
		}
		
		/*
		 * 如果他是字符串，则只有为“true”时才为真
		 */
		if ( reader.isString ( index ) )
		{
			temp_bool = Boolean.valueOf( reader.getCellRichStringValue(index).getString() );
		}
		
		return temp_bool;
	}
	
	
	/**
	 * 方法 readCellAsNumeric
	 * 将 index 所指定的单元格视为 数字 型的值来读取；
	 * 如果它本身是数字，则直接返回其值；
	 * 如果它是布尔型，则true代表1,false代表0；
	 * 如果他是字符串，将尝试分析它为数字,分析失败则直接返回null；
	 * 如果匹配失败返回 null；
	 * @param index 指定cell的位置
	 * @return 匹配后读得的结果，如果匹配失败返回 null
	 */
	public Double readCellAsNumeric ( int index )
	{
		Double temp_double = null;
		
		/*
		 * 如果它本身是数字，则直接返回
		 */
		if ( reader.isNumeric ( index ) )
		{
			temp_double = reader.getCellNumericValue(index);
			return temp_double;
		}
		
		/*
		 * 如果它是布尔型，则true代表1,false代表0
		 */
		if ( reader.isBoolean ( index ) )
		{
			if ( reader.getCellBooleanValue(index) )
			{
				temp_double = 1.0;
			}
			else
			{
				temp_double = 0.0;
			}
			
			return temp_double;
		}
		
		/*
		 * 如果他是字符串，将尝试分析它为数字,分析失败则直接返回null
		 */
		if ( reader.isString ( index ) )
		{
			try{
				temp_double = Double.parseDouble( reader.getCellRichStringValue(index).getString() );
			}
			catch ( NumberFormatException e )
			{
				return null;
			}
		}
		
		return temp_double;
	}
	
	/**
	 * 方法 readCellAsString
	 * 将 index 所指定的单元格视为 字符串 型的值来读取；
	 * 如果他是字符串，则直接返回；
	 * 如果它本身是数字，则转换为字符串返回；
	 * 如果它是布尔型，则true换为“true”,false换为“false”；
	 * 如果匹配失败返回 null；
	 * @param index 指定cell的位置
	 * @return 匹配后读得的结果，如果匹配失败返回 null
	 */
	public String readCellAsString ( int index )
	{
		String temp_string = null;		
			
		/*
		 * 如果他是字符串，则直接返回
		 */
		if ( reader.isString ( index ) )
		{
			temp_string= reader.getCellRichStringValue(index).getString();
			return temp_string;
		}
		
		/*
		 * 如果它本身是数字，则转换为字符串返回
		 */
		if ( reader.isNumeric ( index ) )
		{
			Double tempdouble = reader.getCellNumericValue(index);
			Long templong =  tempdouble.longValue();

			temp_string = String.valueOf( (templong<tempdouble)?templong:templong  );
			return temp_string;
		}
		
		/*
		 * 如果它是布尔型，则true换为“true”,false换为“false”
		 */
		if ( reader.isBoolean ( index ) )
		{
			if ( reader.getCellBooleanValue(index) )
			{
				temp_string = "true";
			}
			else
			{
				temp_string = "false";
			}
		}
		
		return temp_string;
	}
	
	/**
	 * 方法 readCellAsDate
	 * 将 index 所指定的单元格视为 日期时间 型的值来读取；
	 * 如果格式不合，则返回null
	 * @param index 指定cell的位置
	 * @return Cell日期时间的值，如果格式不合，则返回null
	 */
	public Date readCellAsDate ( int index )
	{
		Date temp_date = reader.getCellDateValue ( index );
		
		return temp_date;
	}
}
